home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / pcl / docs.lha / cmu-user / cmu-user.cp < prev    next >
Text File  |  1992-07-15  |  14KB  |  246 lines
  1. \entry{time parsing}{17}{time parsing}
  2. \entry{time formatting}{17}{time formatting}
  3. \entry{debugger}{20}{debugger}
  4. \entry{evaluation debugger}{21}{evaluation}{debugger}
  5. \entry{stack frames}{21}{stack frames}
  6. \entry{frames stack}{21}{frames}{stack}
  7. \entry{function names}{22}{function}{names}
  8. \entry{names function}{22}{names}{function}
  9. \entry{external entry points}{23}{external entry points}
  10. \entry{entry points external}{23}{entry points}{external}
  11. \entry{block compilation debugger implications}{23}{block compilation}{debugger implications}
  12. \entry{external stack frame kind}{23}{external}{stack frame kind}
  13. \entry{optional stack frame kind}{23}{optional}{stack frame kind}
  14. \entry{cleanup stack frame kind}{23}{cleanup}{stack frame kind}
  15. \entry{tail recursion}{23}{tail recursion}
  16. \entry{recursion tail}{23}{recursion}{tail}
  17. \entry{unknown code locations}{24}{unknown code locations}
  18. \entry{locations unknown}{24}{locations}{unknown}
  19. \entry{interrupts}{24}{interrupts}
  20. \entry{errors run-time}{24}{errors}{run-time}
  21. \entry{variables debugger access}{24}{variables}{debugger access}
  22. \entry{debug variables}{24}{debug variables}
  23. \entry{availability of debug variables}{25}{availability of debug variables}
  24. \entry{validity of debug variables}{25}{validity of debug variables}
  25. \entry{debug optimization quality}{25}{debug optimization quality}
  26. \entry{evaluation debugger}{25}{evaluation}{debugger}
  27. \entry{source location printing debugger}{25}{source location printing}{debugger}
  28. \entry{debug optimization quality}{27}{debug optimization quality}
  29. \entry{block basic}{27}{block}{basic}
  30. \entry{block start location}{27}{block}{start location}
  31. \entry{policy debugger}{27}{policy}{debugger}
  32. \entry{debug optimization quality}{27}{debug optimization quality}
  33. \entry{optimize declaration}{27}{optimize declaration}
  34. \entry{inline expansion}{28}{inline expansion}
  35. \entry{semi-inline expansion}{28}{semi-inline expansion}
  36. \entry{tracing}{30}{tracing}
  37. \entry{function tracing}{30}{function}{tracing}
  38. \entry{encapsulation}{32}{encapsulation}
  39. \entry{advising}{32}{advising}
  40. \entry{compiling}{33}{compiling}
  41. \entry{compilation units}{35}{compilation}{units}
  42. \entry{undefined warnings}{35}{undefined warnings}
  43. \entry{context sensitive declarations}{36}{context sensitive declarations}
  44. \entry{declarations context-sensitive}{36}{declarations}{context-sensitive}
  45. \entry{error messages compiler}{37}{error messages}{compiler}
  46. \entry{compiler error messages}{37}{compiler error messages}
  47. \entry{original source}{39}{original source}
  48. \entry{actual source}{39}{actual source}
  49. \entry{processing path}{39}{processing path}
  50. \entry{macroexpansion}{39}{macroexpansion}
  51. \entry{source-to-source transformation}{39}{source-to-source transformation}
  52. \entry{severity of compiler errors}{40}{severity of compiler errors}
  53. \entry{compiler error severity}{40}{compiler error severity}
  54. \entry{macroexpansion errors during}{40}{macroexpansion}{errors during}
  55. \entry{read errors compiler}{40}{read errors}{compiler}
  56. \entry{error messages verbosity}{41}{error messages}{verbosity}
  57. \entry{verbosity of error messages}{41}{verbosity}{of error messages}
  58. \entry{types in python}{42}{types}{in python}
  59. \entry{compile time type errors}{42}{compile time type errors}
  60. \entry{type checking at compile time}{42}{type checking}{at compile time}
  61. \entry{precise type checking}{43}{precise type checking}
  62. \entry{type checking precise}{43}{type checking}{precise}
  63. \entry{weakened type checking}{43}{weakened type checking}
  64. \entry{type checking weakened}{43}{type checking}{weakened}
  65. \entry{existing programs to run}{44}{existing programs}{to run}
  66. \entry{types portability}{44}{types}{portability}
  67. \entry{compatibility with other Lisps}{44}{compatibility with other Lisps}
  68. \entry{policy compiler}{46}{policy}{compiler}
  69. \entry{compiler policy}{46}{compiler policy}
  70. \entry{optimize declaration}{46}{optimize declaration}
  71. \entry{declarations \code{optimize}}{46}{declarations}{\code{optimize}}
  72. \entry{speed optimization quality}{46}{speed optimization quality}
  73. \entry{compilation-speed optimization quality}{46}{compilation-speed optimization quality}
  74. \entry{space optimization quality}{46}{space optimization quality}
  75. \entry{debug optimization quality}{46}{debug optimization quality}
  76. \entry{safety optimization quality}{46}{safety optimization quality}
  77. \entry{inhibit-warnings optimization quality}{46}{inhibit-warnings optimization quality}
  78. \entry{optimize-interface declaration}{46}{optimize-interface declaration}
  79. \entry{declarations \code{optimize-interface}}{46}{declarations}{\code{optimize-interface}}
  80. \entry{open-coding}{47}{open-coding}
  81. \entry{inline expansion}{47}{inline expansion}
  82. \entry{static functions}{47}{static functions}
  83. \entry{types in python}{50}{types}{in python}
  84. \entry{types equivalence}{51}{types}{equivalence}
  85. \entry{canonicalization of types}{51}{canonicalization of types}
  86. \entry{equivalence of types}{51}{equivalence of types}
  87. \entry{member types}{51}{member types}
  88. \entry{union (\code{or}) types}{52}{union (\code{or}) types}
  89. \entry{or (union) types}{52}{or (union) types}
  90. \entry{NIL type}{52}{NIL type}
  91. \entry{empty type the}{52}{empty type}{the}
  92. \entry{errors result type of}{52}{errors}{result type of}
  93. \entry{function types}{52}{function}{types}
  94. \entry{types function}{52}{types}{function}
  95. \entry{values declaration}{53}{values declaration}
  96. \entry{structure types}{54}{structure types}
  97. \entry{defstruct types}{54}{defstruct types}
  98. \entry{types structure}{54}{types}{structure}
  99. \entry{freeze-type declaration}{54}{freeze-type declaration}
  100. \entry{types restrictions on}{54}{types}{restrictions on}
  101. \entry{style recommendations}{55}{style recommendations}
  102. \entry{type inference}{55}{type inference}
  103. \entry{inference of types}{55}{inference of types}
  104. \entry{derivation of types}{55}{derivation of types}
  105. \entry{local call type inference}{56}{local call}{type inference}
  106. \entry{function type inference}{56}{function}{type inference}
  107. \entry{operation specific type inference}{57}{operation specific type inference}
  108. \entry{arithmetic type inference}{57}{arithmetic type inference}
  109. \entry{numeric type inference}{57}{numeric}{type inference}
  110. \entry{dynamic type inference}{57}{dynamic type inference}
  111. \entry{conditional type inference}{57}{conditional type inference}
  112. \entry{type inference dynamic}{57}{type inference}{dynamic}
  113. \entry{type checking optimization}{58}{type checking}{optimization}
  114. \entry{optimization type check}{58}{optimization}{type check}
  115. \entry{complemented type checks}{59}{complemented type checks}
  116. \entry{optimization}{59}{optimization}
  117. \entry{let optimization}{60}{let optimization}
  118. \entry{optimization let}{60}{optimization}{let}
  119. \entry{constant folding}{61}{constant folding}
  120. \entry{folding constant}{61}{folding}{constant}
  121. \entry{constant-function declaration}{61}{constant-function declaration}
  122. \entry{unused expression elimination}{61}{unused expression elimination}
  123. \entry{dead code elimination}{61}{dead code elimination}
  124. \entry{control optimization}{61}{control optimization}
  125. \entry{optimization control}{61}{optimization}{control}
  126. \entry{unreachable code deletion}{62}{unreachable code deletion}
  127. \entry{dead code elimination}{62}{dead code elimination}
  128. \entry{multiple value optimization}{64}{multiple value optimization}
  129. \entry{optimization multiple value}{64}{optimization}{multiple value}
  130. \entry{source-to-source transformation}{64}{source-to-source transformation}
  131. \entry{transformation source-to-source}{64}{transformation}{source-to-source}
  132. \entry{style recommendations}{65}{style recommendations}
  133. \entry{tail recursion}{65}{tail recursion}
  134. \entry{recursion}{65}{recursion}
  135. \entry{local call}{67}{local call}
  136. \entry{call local}{67}{call}{local}
  137. \entry{function call local}{67}{function call}{local}
  138. \entry{recursion self}{67}{recursion}{self}
  139. \entry{closures}{68}{closures}
  140. \entry{tail recursion}{68}{tail recursion}
  141. \entry{recursion tail}{68}{recursion}{tail}
  142. \entry{return values local call}{69}{return values}{local call}
  143. \entry{local call return values}{69}{local call}{return values}
  144. \entry{block compilation}{69}{block compilation}
  145. \entry{compilation block}{69}{compilation}{block}
  146. \entry{declarations block compilation}{70}{declarations}{block compilation}
  147. \entry{start-block declaration}{70}{start-block declaration}
  148. \entry{end-block declaration}{70}{end-block declaration}
  149. \entry{compile-file block compilation arguments}{71}{compile-file}{block compilation arguments}
  150. \entry{inline expansion}{72}{inline expansion}
  151. \entry{expansion inline}{72}{expansion}{inline}
  152. \entry{call inline}{72}{call}{inline}
  153. \entry{function call inline}{72}{function call}{inline}
  154. \entry{optimization function call}{72}{optimization}{function call}
  155. \entry{recording of inline expansions}{73}{recording of inline expansions}
  156. \entry{maybe-inline declaration}{73}{maybe-inline declaration}
  157. \entry{object representation}{74}{object representation}
  158. \entry{representation object}{74}{representation}{object}
  159. \entry{efficiency of objects}{74}{efficiency}{of objects}
  160. \entry{lists efficiency of}{75}{lists}{efficiency of}
  161. \entry{structure types efficiency of}{75}{structure types}{efficiency of}
  162. \entry{arrays efficiency of}{75}{arrays}{efficiency of}
  163. \entry{vectors efficiency of}{75}{vectors}{efficiency of}
  164. \entry{bit-vectors efficiency of}{76}{bit-vectors}{efficiency of}
  165. \entry{hash-tables efficiency of}{76}{hash-tables}{efficiency of}
  166. \entry{numeric types}{76}{numeric}{types}
  167. \entry{types numeric}{76}{types}{numeric}
  168. \entry{descriptors object}{77}{descriptors}{object}
  169. \entry{object representation}{77}{object representation}
  170. \entry{representation object}{77}{representation}{object}
  171. \entry{consing overhead of}{77}{consing}{overhead of}
  172. \entry{non-descriptor representations}{77}{non-descriptor representations}
  173. \entry{stack numbers}{77}{stack numbers}
  174. \entry{variables non-descriptor}{78}{variables}{non-descriptor}
  175. \entry{type declarations variable}{78}{type declarations}{variable}
  176. \entry{efficiency of numeric variables}{78}{efficiency}{of numeric variables}
  177. \entry{generic arithmetic}{78}{generic arithmetic}
  178. \entry{arithmetic generic}{78}{arithmetic}{generic}
  179. \entry{numeric operation efficiency}{78}{numeric}{operation efficiency}
  180. \entry{fixnums}{79}{fixnums}
  181. \entry{bignums}{79}{bignums}
  182. \entry{word integers}{80}{word integers}
  183. \entry{floating point efficiency}{80}{floating point efficiency}
  184. \entry{specialized array types}{80}{specialized array types}
  185. \entry{array types specialized}{80}{array types}{specialized}
  186. \entry{types specialized array}{80}{types}{specialized array}
  187. \entry{local call numeric operands}{81}{local call}{numeric operands}
  188. \entry{call numeric operands}{81}{call}{numeric operands}
  189. \entry{numbers in local call}{81}{numbers in local call}
  190. \entry{characters}{81}{characters}
  191. \entry{strings}{81}{strings}
  192. \entry{efficiency general hints}{81}{efficiency}{general hints}
  193. \entry{compilation why to}{81}{compilation}{why to}
  194. \entry{consing}{82}{consing}
  195. \entry{garbage collection}{82}{garbage collection}
  196. \entry{memory allocation}{82}{memory allocation}
  197. \entry{efficiency of memory use}{82}{efficiency}{of memory use}
  198. \entry{argument syntax efficiency}{82}{argument syntax}{efficiency}
  199. \entry{efficiency of argument syntax}{82}{efficiency}{of argument syntax}
  200. \entry{keyword argument efficiency}{82}{keyword argument efficiency}
  201. \entry{rest argument efficiency}{82}{rest argument efficiency}
  202. \entry{mapping efficiency of}{83}{mapping}{efficiency of}
  203. \entry{trace files}{83}{trace files}
  204. \entry{assembly listing}{83}{assembly listing}
  205. \entry{listing files trace}{83}{listing files}{trace}
  206. \entry{Virtual Machine (VM, or IR2) representation}{83}{Virtual Machine (VM, or IR2) representation}
  207. \entry{implicit continuation representation (IR1)}{83}{implicit continuation representation (IR1)}
  208. \entry{continuations implicit representation}{83}{continuations}{implicit representation}
  209. \entry{efficiency notes}{84}{efficiency notes}
  210. \entry{notes efficiency}{84}{notes}{efficiency}
  211. \entry{tuning}{84}{tuning}
  212. \entry{types uncertainty}{84}{types}{uncertainty}
  213. \entry{uncertainty of types}{84}{uncertainty of types}
  214. \entry{type checking efficiency of}{84}{type checking}{efficiency of}
  215. \entry{efficiency of type checking}{84}{efficiency}{of type checking}
  216. \entry{optimization type check}{84}{optimization}{type check}
  217. \entry{representation efficiency notes}{85}{representation efficiency notes}
  218. \entry{efficiency notes for representation}{85}{efficiency notes}{for representation}
  219. \entry{object representation efficiency notes}{85}{object representation efficiency notes}
  220. \entry{stack numbers}{85}{stack numbers}
  221. \entry{non-descriptor representations}{85}{non-descriptor representations}
  222. \entry{descriptor representations forcing of}{85}{descriptor representations}{forcing of}
  223. \entry{verbosity of efficiency notes}{86}{verbosity}{of efficiency notes}
  224. \entry{efficiency notes verbosity}{86}{efficiency notes}{verbosity}
  225. \entry{profiling}{86}{profiling}
  226. \entry{timing}{86}{timing}
  227. \entry{consing}{86}{consing}
  228. \entry{tuning}{86}{tuning}
  229. \entry{CPU time interpretation of}{88}{CPU time}{interpretation of}
  230. \entry{run time interpretation of}{88}{run time}{interpretation of}
  231. \entry{interpretation of run time}{88}{interpretation of run time}
  232. \entry{benchmarking techniques}{89}{benchmarking techniques}
  233. \entry{aliens}{92}{aliens}
  234. \entry{types alien}{92}{types}{alien}
  235. \entry{types foreign language}{92}{types}{foreign language}
  236. \entry{pointers}{92}{pointers}
  237. \entry{malloc C function}{92}{malloc}{C function}
  238. \entry{free C function}{92}{free}{C function}
  239. \entry{unix interrupts}{94}{unix interrupts}
  240. \entry{interrupts}{94}{interrupts}
  241. \entry{object sets}{97}{object sets}
  242. \entry{Function Index}{132}{Function Index}
  243. \entry{Variable Index}{135}{Variable Index}
  244. \entry{Type Index}{136}{Type Index}
  245. \entry{Concept Index}{137}{Concept Index}
  246.